home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / BODI / WINDOWS.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  25.1 KB  |  835 lines
  1. /**************************************************************************/
  2. /*  FILE:  WINDOWS.C        PROGRAM TITLE: DeskSET II Alpha Version   */
  3. /*  Date Created: 12/15/87                          */ 
  4. /*  Last Modified: 01/26/89                          */
  5. /*                                      */
  6. /*  Description: Window Handler Routines                  */
  7. /*  Routines: o  open_windows() - open initial text and preview window      */
  8. /*          o  shut _windows()- close text and preview, if open      */
  9. /*            o  do_window()    - create a window and open it          */ 
  10. /*          o  top_window()   - top a window                  */
  11. /*          o  close_window() - close and delete a window          */
  12. /*          o  full_window()  - full size a window              */
  13. /*          o  arrow_window() - arrow handling of a window          */
  14. /*          o  hslide_window()- horizontal slider              */
  15. /*          o  vslide_window()- vertical slider of a window          */
  16. /*          o  size_window()  - size a window                  */
  17. /*          o  move_window()  - move a window                  */
  18. /*          o  slider_chk()   - Update Slider Info              */
  19. /*          o  get_work()     - Returns work area of window...          */
  20. /*          o  sliderv()    - size vertical slider bar          */
  21. /*          o  sliderh()    - size horizontal slider bar          */
  22. /*          o  wupline()    - up arrow function              */
  23. /*          o  wdnline()    - down arrow function              */
  24. /*          o  wrtline()    - right arrow function              */
  25. /*          o  wlftline()    - left arrow function              */
  26. /*          o  prev_cleanup() - Cleanup preview window          */
  27. /*          o  size_fit_handle- Calc page area for size to fit and alt  */
  28. /**************************************************************************/
  29.  
  30. /**************************************************************************/
  31. /* HISTORY                                  */
  32. /*                                       */
  33. /* 11/07/89 - Replace all calls to scale_iv() with scaler()          */
  34. /*          hslide_window() -   "          "             "          */
  35. /*          vslide_window() -   "         "             "          */
  36. /*          size_window()   -   "          "             "          */
  37. /*          slider_chk()    -   "          "             "              */
  38. /*          sliderv()          -   "          "             "              */
  39. /*          sliderh()       -   "          "             "              */
  40. /**************************************************************************/
  41.  
  42. /**************************************************************************/
  43. /* INCLUDE FILES                              */
  44. /**************************************************************************/
  45. #include "define.h"
  46. #include "gemdefs.h"
  47. #include <obdefs.h>
  48. #include "deskset2.h"
  49. #include "alert.h"
  50.  
  51. /**************************************************************************/
  52. /* DEFINES                                  */
  53. /**************************************************************************/
  54. #define max(x,y)   (((x) > (y)) ? (x) :  (y))    /* Max function              */
  55. #define    min(x,y)   (((x) < (y)) ? (x) :  (y))    /* Min function          */
  56.  
  57. /**************************************************************************/
  58. /* EXTERNALS                                  */
  59. /**************************************************************************/
  60. extern int hpage_size;                /* width and height of    */
  61. extern int vpage_size;                /* paper in MU units      */
  62.  
  63. extern int pagew;                /* current page width and */
  64. extern int pageh;                /* height in pixels.      */
  65.  
  66. extern int shandle;                /* Screen Handle...      */
  67.  
  68. extern int view_size;                /* Current scale size...  */
  69. extern FDB page_MFDB;                /* MFDB of preview area   */
  70. extern int ptsin[];                /* PTSIN[] array...       */
  71. extern unsigned long gl_region_ptr;        /* Ptr to current active  */
  72.                         /* text region          */
  73. extern unsigned long gl_grregion_ptr;
  74. extern unsigned long region_ptr;
  75.  
  76. extern GRECT page_area;             /* GRECT of Preview MFDB  */
  77. extern GRECT page;
  78.  
  79. extern int BSTATE;
  80. extern int BREAL;
  81. extern int nada();
  82. extern int dummy;
  83. extern int pxy[];
  84. extern int blit_flag;
  85. extern int force_draw_flag;
  86. extern int ruler_flag;
  87. extern int xruler_offset;
  88. extern int yruler_offset;
  89. extern int cur_scale;
  90.  
  91. extern long TWart_ptr;                /* TW current article     */
  92.  
  93. extern OBJECT *ad_menu;
  94. extern int article_flag;
  95. extern char pfname[];                /* preview window title     */
  96. extern char basefname[];            /* base page window title*/
  97.  
  98. extern int unit_type;
  99. extern int active_prim;
  100.     
  101. /**************************************************************************/
  102. /* GLOBAL VARIABLES                              */
  103. /**************************************************************************/
  104. int txt_handle;                    /* text window handle     */
  105. int prev_handle;                /* preview window handle  */
  106.  
  107. GRECT curr;                    /* Current area of window */
  108. GRECT prev;                    /* Previous area of window*/
  109. GRECT full;                    /* Full-size of window      */
  110.  
  111. GRECT pwork;                    /* Preview work area...   */
  112. GRECT twork;                    /* txt work area...      */
  113. GRECT cpwork;                    /* work area of       */
  114.                         /* preview window      */
  115. GRECT dpwork;                    /* blit area of preview   */
  116.                         /* work window          */
  117.  
  118. GRECT scrn_area;                /* GRECT of ScreenMFDB... */
  119. GRECT clip2;                    /* GRECT of clip area...  */
  120.  
  121. long location = 0x0L;                /* Screen to Screen Blit  */
  122.  
  123.  
  124. char *winfo[][4] = {                /* Size Message          */
  125.          {" Size To Fit - Inches                ",
  126.           " Size To Fit - Picas                 ",
  127.           " Size To Fit - Centimeters           ",
  128.           " Size To Fit - Ciceros               "},
  129.  
  130.          {" 50% Size - Inches                   ",
  131.           " 50% Size - Picas                    ",
  132.           " 50% Size - Centimeters              ",
  133.           " 50% Size - Ciceros                  "},
  134.  
  135.          {" 75% Size - Inches                   ",
  136.           " 75% Size - Picas                    ",
  137.           " 75% Size - Centimeters              ",
  138.           " 75% Size - Ciceros                  "},
  139.  
  140.                  {" Actual Size - Inches                ",
  141.                   " Actual Size - Picas                 ",
  142.                   " Actual Size - Centimeters           ",
  143.                   " Actual Size - Ciceros               "},
  144.  
  145.                  {" 200% Size - Inches                  ",
  146.                   " 200% Size - Picas                   ",
  147.                   " 200% Size - Centimeters             ",
  148.                   " 200% Size - Ciceros                 "},
  149.  
  150.                  {" Alternate Pages - Left Page Active - Inches     ",
  151.                   " Alternate Pages - Left Page Active - Picas      ",
  152.                   " Alternate Pages - Left Page Active - Centimeters",
  153.                   " Alternate Pages - Left Page Active - Ciceros    "},
  154.  
  155.          {" Alternate Pages - Right Page Active - Inches     ",
  156.           " Alternate Pages - Right Page Active - Picas      ",
  157.           " Alternate Pages - Right Page Active - Centimeters",
  158.           " Alternate Pages - Right Page Active - Ciceros    "},
  159.  
  160.          {"  "," "," "," "}
  161.                 };
  162.  
  163.  
  164. char    *TWmesg[] = {                /* Text window Messages   */
  165.              "Article :",
  166.              " >> "
  167.             };
  168.  
  169. int (*arrow_funcs)();
  170. int (*slide_arrow)();
  171. int sliderv();
  172. int sliderh();
  173. int wupline();
  174. int wdnline();
  175. int wrtline();
  176. int wlfline();
  177.  
  178. int pixx,pixy;
  179. int xruler_offset;
  180. int yruler_offset;
  181.  
  182. /**************************************************************************/
  183. /* Function:    open_windows()                          */
  184. /* Description: Create and open preview and text window.                  */
  185. /* IN: none                                  */
  186. /* OUT: none                                  */
  187. /**************************************************************************/
  188. open_windows()
  189. {
  190.     int wind_type;
  191.     int tmp;
  192.  
  193.     wind_type = (NAME | INFO | FULLER | SIZER | MOVER |
  194.          UPARROW | DNARROW | VSLIDE | LFARROW |
  195.          RTARROW | HSLIDE);
  196.  
  197.     wind_get(0,WF_WORKXYWH,&full.g_x,&full.g_y,&full.g_w,&full.g_h);
  198.     txt_handle = wind_create(wind_type,full.g_x,full.g_y,full.g_w,full.g_h);
  199.     prev_handle= wind_create(wind_type,full.g_x,full.g_y,full.g_w,full.g_h);
  200.  
  201.     tmp = ((full.g_w/10)-2) + ((full.g_w/20)*9) + 24;
  202.  
  203.     if(txt_handle >= 0)
  204.     {
  205.     set_TWrows();
  206.        do_window(txt_handle,TWmesg[0],TWmesg[1],
  207.              tmp,full.g_y+1,(full.g_w/20)*9-30,(full.g_h/2));
  208.        get_work(txt_handle);
  209.     }
  210.  
  211.  
  212.     if(prev_handle >=0)
  213.     {
  214.        strcpy(pfname," Preview Window ");
  215.        strcpy(basefname," Base Page Window ");
  216.        do_window(prev_handle,pfname,winfo[7][unit_type],
  217.             (full.g_w/10)-2,full.g_y+1,(full.g_w/20)*9+20,full.g_h-7);
  218.        get_work(prev_handle);
  219.        update_preview_blit();
  220.     }
  221. }
  222.  
  223.  
  224.  
  225. /**************************************************************************/
  226. /* Function:    close_windows()                          */
  227. /* Description: Close and delete preview and text window.          */
  228. /* IN:  none                                  */
  229. /* OUT: none                                  */
  230. /**************************************************************************/
  231. shut_windows()
  232. {
  233.     if(txt_handle)
  234.     {
  235.     wind_close(txt_handle);
  236.     wind_delete(txt_handle);
  237.     }
  238.  
  239.     if(prev_handle)
  240.     {
  241.     wind_close(prev_handle);
  242.         wind_delete(prev_handle);
  243.     }
  244. }
  245.  
  246.  
  247.  
  248. /**************************************************************************/
  249. /* Function:    do_window()                          */
  250. /* Description: Open a window                          */
  251. /* IN:  wi_handle - window handle                      */
  252. /*    name      - name for title bar                      */
  253. /*    info      - text for info bar                      */
  254. /*    x,y,w,h   - size to open window to                  */
  255. /* OUT: none                                  */
  256. /**************************************************************************/
  257. do_window(wi_handle,name,info,x,y,w,h)
  258. int wi_handle;
  259. char *name;
  260. char *info;
  261. int x,y;
  262. int w,h;
  263. {
  264.       wind_set(wi_handle,WF_NAME,name,0,0);
  265.       wind_set(wi_handle,WF_INFO,info,0,0);
  266.       wind_set(wi_handle,WF_HSLIDE,1,0,0,0);
  267.       wind_set(wi_handle,WF_VSLIDE,1,0,0,0);
  268.       wind_set(wi_handle,WF_HSLSIZE,1000,0,0,0);
  269.       wind_set(wi_handle,WF_VSLSIZE,1000,0,0,0);
  270.       graf_growbox(10,10,20,20,x,y,w,h);
  271.       wind_open(wi_handle,x,y,w,h);
  272. }
  273.  
  274.  
  275.  
  276. /**************************************************************************/
  277. /* Function:    top_window()                            */
  278. /* Description: Top a window :-)                      */
  279. /* IN:  wi_handle - handle of window                      */
  280. /**************************************************************************/
  281. top_window(wi_handle,txtptr)
  282. int wi_handle;
  283. char *txtptr;
  284. {
  285.      register int i;
  286.  
  287.     if(wi_handle == txt_handle && article_flag == 1)
  288.     {
  289.        alert_cntre(ALERT25);    /* Article still open    */
  290.        return;
  291.     }
  292.     wind_set(wi_handle,WF_TOP,0,0,0,0);
  293.     if(wi_handle == txt_handle)
  294.     {
  295.        for(i = TFILE;i <= TOPTIONS;i++)
  296.         menu_ienable(ad_menu,0x8000|i,FALSE);    /* Disable menus */
  297.        menu_ienable(ad_menu,0x8000|TEXT,TRUE);
  298.        menu_ienable(ad_menu,OADDPRIM,FALSE);
  299.        menu_ienable(ad_menu,ODELPRIM,FALSE);
  300.        menu_ienable(ad_menu,OPCOORD,FALSE);
  301.        menu_ienable(ad_menu,OMOVEFNT,FALSE);
  302.        menu_ienable(ad_menu,OMOVEBAK,FALSE);
  303.  
  304.        menu_ienable(ad_menu,RUNLINK,FALSE);
  305.        menu_ienable(ad_menu,RDELETE,FALSE);
  306.        menu_ienable(ad_menu,RCOORD,FALSE);
  307.        menu_ienable(ad_menu,RMOVEFNT,FALSE);
  308.        menu_ienable(ad_menu,RMOVEBAK,FALSE);
  309.  
  310.        if (gl_region_ptr)
  311.             setTWArticle(gl_region_ptr,txtptr);
  312.     }
  313.     else
  314.     {
  315.        for(i = TFILE;i <= TOPTIONS;i++)
  316.         menu_ienable(ad_menu,0x8000|i,TRUE);
  317.        menu_ienable(ad_menu,0x8000|TEXT,FALSE);
  318.        if(TWart_ptr)
  319.             saveTWptrs();
  320.     }
  321.         active_prim = FALSE;
  322. }
  323.  
  324.  
  325.  
  326. /**************************************************************************/
  327. /* Function:    close_window()                          */
  328. /* Description: Close a window                          */
  329. /* IN: wi_handle - handle of window                      */
  330. /**************************************************************************/
  331. close_window(wi_handle)
  332. int wi_handle;
  333. {
  334.      wind_get(wi_handle,WF_CURRXYWH,&curr.g_x,&curr.g_y,&curr.g_w,&curr.g_h);
  335.      wind_close(wi_handle);
  336.      graf_shrinkbox(10,10,20,20,curr.g_x,curr.g_y,curr.g_w,curr.g_h);
  337.      wind_delete(wi_handle);
  338.  
  339.      if(wi_handle == txt_handle) txt_handle = FALSE;
  340.      else if(wi_handle == prev_handle) prev_handle = FALSE;
  341. }
  342.  
  343.  
  344.  
  345. /**************************************************************************/
  346. /* Function:    full_window()                          */
  347. /* Description: full size a window                      */
  348. /* IN: wi_handle - handle of window to full                  */
  349. /**************************************************************************/
  350. full_window(wi_handle)
  351. register int wi_handle;
  352. {
  353.      wind_get(wi_handle,WF_CURRXYWH,&curr.g_x,&curr.g_y,&curr.g_w,&curr.g_h);
  354.      wind_get(wi_handle,WF_FULLXYWH,&full.g_x,&full.g_y,&full.g_w,&full.g_h);
  355.  
  356.      if( rc_equal(&curr,&full))
  357.      {
  358.        wind_get(wi_handle,WF_PREVXYWH,&prev.g_x,&prev.g_y,&prev.g_w,&prev.g_h);
  359.        graf_shrinkbox(prev.g_x,prev.g_y,prev.g_w,prev.g_h,
  360.               full.g_x,full.g_y,full.g_w,full.g_h);
  361.        wind_set(wi_handle,WF_CURRXYWH,prev.g_x,prev.g_y,prev.g_w,prev.g_h);
  362.      }
  363.      else
  364.      {
  365.        graf_growbox(curr.g_x,curr.g_y,curr.g_w,curr.g_h,
  366.             full.g_x,full.g_y,full.g_w,full.g_h);
  367.        wind_set(wi_handle,WF_CURRXYWH,full.g_x,full.g_y,full.g_w,full.g_h);
  368.      }
  369.      get_work(wi_handle);
  370.      if(wi_handle == prev_handle)
  371.      {
  372.     if( (view_size == PSIZE)  ||
  373.         (view_size == PADJCNT))
  374.         {
  375.        gsx_moff();
  376.        size_fit_handle();
  377.        gsx_mon();
  378.        if(ruler_flag)
  379.         init_rulers();
  380.         }
  381.     else
  382.       prev_cleanup();
  383.      }
  384.     else TWslider_chk();
  385. }
  386.  
  387.  
  388.  
  389. /**************************************************************************/
  390. /* Function:     arrow_window()                          */
  391. /* Description:  arrow button control of a window              */
  392. /* NOTE: limits must be put in so that the arrows don't exceed them       */
  393. /* IN: wi_handle - handle of window                      */
  394. /*     action    - button pressed - arrow, slider, scroll bar          */
  395. /* OUT: none                                  */
  396. /**************************************************************************/
  397. arrow_window(wi_handle,action)
  398. int wi_handle;
  399. int action;
  400. {
  401.      int tmp_buff[8];
  402.      int event;
  403.  
  404.      if(wi_handle == txt_handle)        /* To TWindow handler */
  405.         return(TW_arrow(action));
  406.      
  407.      region_ptr = gl_region_ptr = gl_grregion_ptr = 0L;
  408.      if((wi_handle == prev_handle) && (view_size != PSIZE)
  409.                    && (view_size != PADJCNT))
  410.      {
  411.       set_clip(TRUE,&pwork);
  412.       scrntomu(16,16,&pixx,&pixy,1);        /* should be in do_view_size*/
  413.  
  414.  
  415.       arrow_funcs = &nada;
  416.       slide_arrow = &sliderv;
  417.  
  418.       switch(action)
  419.        {
  420.          case WA_UPPAGE:  
  421.            page_area.g_y = max(page_area.g_y - page_area.g_h,0L);
  422.            break;
  423.  
  424.          case WA_DNPAGE: 
  425. /*            page_area.g_y += page_area.g_h;*/
  426.            page_area.g_y = min(vpage_size - page_area.g_h,page_area.g_y + page_area.g_h);
  427.             break;
  428.  
  429.          case WA_UPLINE:
  430.            page_area.g_y = max(page_area.g_y - pixy,0L);
  431.                    arrow_funcs = &wupline;
  432.            break;
  433.  
  434.          case WA_DNLINE:
  435.            page_area.g_y += pixy;
  436.                    arrow_funcs = &wdnline;
  437.            break;
  438.  
  439.          case WA_LFPAGE:
  440.            page_area.g_x = max(page_area.g_x - page_area.g_w,0L);
  441.            break;
  442.  
  443.          case WA_RTPAGE:
  444. /*           page_area.g_x += page_area.g_w;*/
  445.            page_area.g_x = min(hpage_size - page_area.g_w,page_area.g_x + page_area.g_w);
  446.            break;
  447.  
  448.          case WA_LFLINE:
  449.            page_area.g_x = max(page_area.g_x - pixx,0L);
  450.                    arrow_funcs = &wlfline;
  451.            slide_arrow = &sliderh;
  452.            break;
  453.  
  454.          case WA_RTLINE:
  455.            page_area.g_x += pixx;
  456.            arrow_funcs = &wrtline;
  457.            slide_arrow = &sliderh;
  458.         break;
  459.        }
  460.        if( ((BREAL == 1) || (BREAL == 2))&& (arrow_funcs != &nada))
  461.        {
  462.        do
  463.         {
  464.         (*arrow_funcs)();
  465.         (*slide_arrow)();
  466.         do_blit();
  467.        }while( (BREAL == 1) || (BREAL == 2));
  468.        }
  469.        else
  470.        {
  471.           slider_chk();
  472.           do_blit();
  473.        }
  474.        BSTATE = 0;
  475.       
  476.            for(;;)    /* used to bleed off unwanted messages...*/
  477.            {
  478.         event = evnt_multi((MU_MESAG|MU_TIMER),
  479.                     0,0,0,
  480.                     0,0,0,0,0,
  481.                     0,0,0,0,0,
  482.                     tmp_buff,
  483.                     0,0,        /* timer == 0 */
  484.                     &dummy,&dummy,
  485.                     &dummy,&dummy,
  486.                     &dummy,&dummy);
  487.  
  488.         if(event == MU_TIMER)
  489.                 break;
  490.            }
  491.            BSTATE = 0;
  492.  
  493.     }
  494.     else
  495.     do_blit();
  496. }
  497.  
  498.  
  499.  
  500. /**************************************************************************/
  501. /* Function:     hslide_window()                      */
  502. /* Description:  Horizontal Slider Control                  */
  503. /* IN: wi_handle - handle of window                      */
  504. /*     position  - position of slider in window                  */
  505. /* OUT: none                                  */
  506. /**************************************************************************/
  507. hslide_window(wi_handle,position)
  508. int wi_handle;
  509. int position;
  510. {
  511.     if(wi_handle == prev_handle)
  512.     {
  513.     region_ptr = gl_region_ptr = gl_grregion_ptr = 0L;
  514.         if((view_size != PSIZE) && (view_size != PADJCNT))
  515.         {
  516.           page_area.g_x = scaler(position,hpage_size - page_area.g_w,1000);
  517.       sliderh();
  518.         }
  519.         send_redraw(prev_handle);
  520.     }
  521.     else TWhslide(position);
  522. }
  523.  
  524.  
  525.  
  526. /**************************************************************************/
  527. /* Function:     vslide_window()                      */
  528. /* Description:  Vertical Slider Control                  */
  529. /* IN: wi_handle - handle of window                      */
  530. /*     position  - position of slider in window                  */
  531. /* OUT: none                                  */
  532. /**************************************************************************/
  533. vslide_window(wi_handle,position)
  534. int wi_handle;
  535. int position;
  536. {
  537.     if(wi_handle == prev_handle)
  538.     {
  539.     region_ptr = gl_region_ptr = gl_grregion_ptr = 0L;
  540.     if((view_size != PSIZE) && (view_size != PADJCNT))
  541.     {
  542.       page_area.g_y = scaler(position,vpage_size - page_area.g_h,1000);
  543.       sliderv();
  544.         }
  545.     send_redraw(prev_handle);
  546.     }
  547.      else TWvslide(position);
  548. }
  549.  
  550.  
  551.  
  552. /**************************************************************************/
  553. /* Function:     size_window()                          */
  554. /* Description:  Window Sizer Routine                      */
  555. /* IN: info - handle, x,y,w,h of window                      */
  556. /* OUT: none                                  */
  557. /**************************************************************************/
  558. size_window(info)
  559. register int info[];
  560. {
  561.        wind_set(info[3],WF_CURRXYWH,info[4],info[5],info[6],info[7]);
  562.        get_work(info[3]);
  563.  
  564.        if(info[3] == txt_handle)
  565.        {
  566.       TWslider_chk();
  567.           wind_get(info[3],WF_PREVXYWH,&prev.g_x,&prev.g_y,&prev.g_w,&prev.g_h);
  568.           if((prev.g_w > info[6]) && (prev.g_h >= info[7]) ||
  569.           (prev.g_w >= info[6]) && (prev.g_h > info[7]) )
  570.               do_redraw(info);
  571.        }
  572.        else
  573.        {
  574.           if((view_size != PSIZE) && (view_size != PADJCNT))
  575.           {
  576.         set_clip(TRUE,&pwork);
  577.             wind_get(info[3],WF_PREVXYWH,&prev.g_x,&prev.g_y,
  578.                      &prev.g_w,&prev.g_h);
  579.         clear_window(prev_handle,2,1);
  580.  
  581.             wind_set(prev_handle,WF_VSLSIZE,scaler(1000,page_area.g_h,
  582.                               vpage_size),0,0,0);
  583.         wind_set(prev_handle,WF_HSLSIZE,scaler(1000,page_area.g_w,
  584.                               hpage_size),0,0,0);
  585.              sliderv();
  586.              sliderh();
  587.  
  588.             if((prev.g_w > info[6]) && (prev.g_h >= info[7]) ||
  589.             (prev.g_w >= info[6]) && (prev.g_h > info[7]) )
  590.             {
  591.                 send_redraw(prev_handle);
  592.             }
  593.  
  594.        }
  595.        else
  596.        {
  597.       gsx_moff();
  598.       size_fit_handle();
  599.       gsx_mon();
  600.       if(ruler_flag)
  601.         init_rulers();
  602.       send_redraw(prev_handle);
  603.        }
  604.       }
  605. }
  606.  
  607.  
  608.  
  609. /**************************************************************************/
  610. /* Function:     move_window()                          */
  611. /* Description:  Window Mover Routine                      */
  612. /* IN:  info  - handle,x,y,w,h of window                  */
  613. /**************************************************************************/
  614. move_window(info)
  615. register int info[];
  616. {
  617.     wind_set(info[3],WF_CURRXYWH,info[4],info[5],info[6],info[7]);
  618.     get_work(info[3]);
  619.         if(info[3] == prev_handle)
  620.         {
  621.        clear_window(prev_handle,2,1);
  622.            update_preview_blit();
  623.         }
  624. }
  625.  
  626.  
  627.  
  628. /**************************************************************************/
  629. /* Function:     slider_chk()                          */
  630. /* Description:  Slider Update                          */
  631. /* IN: none                                  */
  632. /* OUT: none                                  */
  633. /* GLOBAL:  page_area - modified to blit preview to screen          */
  634. /**************************************************************************/
  635. slider_chk()
  636. {
  637.    if( (view_size == PSIZE) || (view_size == PADJCNT))
  638.    {
  639.      page_area.g_x = page_area.g_y = 0;
  640.      wind_set(prev_handle,WF_VSLSIZE,1000,0,0,0);
  641.      wind_set(prev_handle,WF_HSLSIZE,1000,0,0,0);
  642.      wind_set(prev_handle,WF_VSLIDE,0,0,0,0);
  643.      wind_set(prev_handle,WF_HSLIDE,0,0,0,0);
  644.    }
  645.    else
  646.    {
  647.      wind_set(prev_handle,WF_VSLSIZE,scaler(1000,page_area.g_h,
  648.           vpage_size),0,0,0);
  649.      wind_set(prev_handle,WF_HSLSIZE,scaler(1000,page_area.g_w,
  650.           hpage_size),0,0,0);
  651.      sliderv();
  652.      sliderh();
  653.    }
  654. }
  655.  
  656.  
  657.  
  658.  
  659. /**************************************************************************/
  660. /* Function:     get_work()                          */
  661. /* Description:  Get work area of window                  */
  662. /* IN: handle - handle of window                      */
  663. /* OUT: none                                  */
  664. /* GLOBAL:  work area variables of window updated.              */
  665. /**************************************************************************/
  666. get_work(handle)
  667. int handle;
  668. {
  669.       if(prev_handle == handle)
  670.       {
  671.           wind_get(prev_handle,WF_WORKXYWH,&pwork.g_x,&pwork.g_y,
  672.                                       &pwork.g_w,&pwork.g_h);
  673.  
  674.       wind_get(prev_handle,WF_CURRXYWH,&cpwork.g_x,&cpwork.g_y,
  675.                        &cpwork.g_w,&cpwork.g_h);
  676.       dpwork.g_x = pwork.g_x;
  677.       dpwork.g_y = pwork.g_y;
  678.           
  679.       if(ruler_flag)
  680.       {
  681.         if(view_size == P200)
  682.             mutoscrn(324,288,&xruler_offset,&yruler_offset,1);
  683.         else
  684.             mutoscrn(648,576,&xruler_offset,&yruler_offset,1);
  685.         dpwork.g_x += xruler_offset;
  686.         dpwork.g_y += yruler_offset;
  687.           dpwork.g_w  = min(pwork.g_w-xruler_offset,pagew);
  688.           dpwork.g_h  = min(pwork.g_h-yruler_offset,pageh);
  689.       }
  690.           else
  691.           {     
  692.          dpwork.g_w = min(pwork.g_w,pagew);
  693.          dpwork.g_h = min(pwork.g_h,pageh);
  694.       }
  695.       
  696.       scrntomu(dpwork.g_w,dpwork.g_h,&page_area.g_w,&page_area.g_h,1);
  697.           update_preview_blit();
  698.       screen_clip();
  699.       }
  700.       else
  701.       if(txt_handle == handle)
  702.       {
  703.            wind_get(txt_handle,WF_WORKXYWH,&twork.g_x,&twork.g_y,
  704.                                    &twork.g_w,&twork.g_h);
  705.        setMrowcol();
  706.       }
  707. }
  708.  
  709.  
  710.  
  711.  
  712.  
  713. /**************************************************************************/
  714. /* Function: sliderv()                              */
  715. /* Description: size vertical slider bar                  */
  716. /**************************************************************************/
  717. sliderv()
  718. {
  719.      if(vpage_size < (page_area.g_y + page_area.g_h))
  720.         page_area.g_y = vpage_size - page_area.g_h;
  721.     
  722.      wind_set(prev_handle,WF_VSLIDE,scaler(1000,page_area.g_y,
  723.           vpage_size - page_area.g_h),0,0,0);
  724.  
  725. }
  726.  
  727.  
  728.  
  729.  
  730. /**************************************************************************/
  731. /* Function: sliderh()                              */
  732. /* Description: size horizontal slider bar                  */
  733. /**************************************************************************/
  734. sliderh()
  735. {
  736.    if(hpage_size < (page_area.g_x + page_area.g_w))
  737.         page_area.g_x = max(hpage_size - page_area.g_w,0);
  738.    if(page_area.g_w > hpage_size)
  739.         page_area.g_w = hpage_size;
  740.    wind_set(prev_handle,WF_HSLIDE,scaler(1000,page_area.g_x,
  741.           hpage_size - page_area.g_w),0,0,0); 
  742. }
  743.  
  744.  
  745.  
  746.  
  747.  
  748. /**************************************************************************/
  749. /* Function: wupline()                              */
  750. /* Description: up arrow function                      */
  751. /**************************************************************************/
  752. wupline()
  753. {
  754.    page_area.g_y = max(page_area.g_y - pixy,0L);
  755. }
  756.  
  757.  
  758.  
  759.  
  760. /**************************************************************************/
  761. /* Function: wdnline()                              */
  762. /* Description: down arrow function                      */
  763. /**************************************************************************/
  764. wdnline()
  765. {
  766.    page_area.g_y += pixy;
  767. }
  768.  
  769.  
  770.  
  771.  
  772.  
  773. /**************************************************************************/
  774. /* Function: wrtline()                              */
  775. /* Description: right arrow function                      */
  776. /**************************************************************************/
  777. wrtline()
  778. {
  779.    page_area.g_x += pixx;
  780. }
  781.  
  782.  
  783.  
  784.  
  785. /**************************************************************************/
  786. /* Function: wlfline()                              */
  787. /* Description: left arrow function                      */
  788. /**************************************************************************/
  789. wlfline()
  790. {
  791.    page_area.g_x = max(page_area.g_x - pixx,0L);
  792. }
  793.  
  794.  
  795.  
  796.  
  797.  
  798. /**************************************************************************/
  799. /* Function: prev_cleanup()                          */
  800. /* Description: Cleanup preview window                      */
  801. /**************************************************************************/
  802. prev_cleanup()
  803. {
  804.         clear_window(prev_handle,2,1);
  805.         slider_chk();
  806.     update_preview_blit();
  807. }
  808.  
  809.  
  810.  
  811.  
  812.  
  813. /**************************************************************************/
  814. /* Function: size_fit_handle()                          */
  815. /* Description: Calc page area for size to fit and PADJCNT          */
  816. /**************************************************************************/
  817. size_fit_handle()
  818. {
  819.        force_draw_flag = TRUE;
  820.            vsf_interior(shandle,0);
  821.        pdraw_fit(view_size);
  822.            zoom_setup();
  823.        cur_scale = get_scale_num(view_size);
  824.        get_work(prev_handle);
  825.        update_preview_blit();
  826.        set_clip(TRUE,&pwork);
  827. /*       gsx_moff();*/
  828.            vr_recfl(shandle,pxy);
  829.        clear_window(prev_handle,2,1);
  830. /*       gsx_mon();*/
  831.        slider_chk();
  832.        set_clip(TRUE,&dpwork);
  833. }
  834.  
  835.